import axios from 'axios'

// 创建axios实例
const api = axios.create({
  baseURL: 'http://localhost:3000', // json-server的默认地址
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 请求拦截器
api.interceptors.request.use(
  config => {
    // 从localStorage中获取token
    const token = localStorage.getItem('token')
    if (token) {
      config.headers['Authorization'] = `Bearer ${token}`
    }
    return config
  },
  error => {
    return Promise.reject(error)
  }
)

// 响应拦截器
api.interceptors.response.use(
  response => {
    // 处理响应数据，确保返回的是数组或对象
    if (response.data === null || response.data === undefined) {
      return []
    }
    return response.data
  },
  error => {
    // 处理401错误（未授权）
    if (error.response && error.response.status === 401) {
      localStorage.removeItem('token')
      localStorage.removeItem('userRole')
      window.location.href = '/login'
    }
    // 处理404错误（资源不存在）
    if (error.response && error.response.status === 404) {
      console.warn('请求的资源不存在:', error.config.url)
      return []
    }
    console.error('API请求错误:', error)
    return Promise.reject(error)
  }
)

// 用户相关API
export const userAPI = {
  // 登录
  login(credentials) {
    return api.get('/用户', {
      params: { 手机号: credentials.phone, 密码: credentials.password }
    })
  },
  
  // 注册
  register(userData) {
    return api.post('/用户', userData)
  },
  
  // 获取用户信息
  getUserInfo(userId) {
    return api.get(`/用户/${userId}`)
  },
  
  // 获取所有用户
  getUsers() {
    return api.get('/用户')
  }
}

// 患者相关API
export const patientAPI = {
  // 获取所有患者
  getPatients(params = {}) {
    return api.get('/患者', { params }).then(patients => {
      // 规范化患者数据格式，确保前端组件可以使用统一的字段名
      return patients.map(p => ({
        patient_id: p.patient_id || p['患者ID'],
        patient_name: p.patient_name || p['姓名'],
        id_card: p.id_card || p['身份证号'],
        gender: p.gender || p['性别'],
        birth_date: p.birth_date || p['出生日期'],
        phone_number: p.phone_number || p['联系方式'],
        address: p.address || p['常住地址'],
        blood_type: p.blood_type || p['血型'] || '未知',
        allergies: p.allergies || p['过敏史'] || '无',
        past_history: p.past_history || p['既往病史'] || '无',
        created_at: p.created_at || p['created_at'] || p['创建时间'],
        creation_time: p.creation_time || p['creation_time'] || (p.created_at || p['created_at'] || p['创建时间'] ? new Date(p.created_at || p['created_at'] || p['创建时间']).toLocaleString() : new Date().toLocaleString())
      }))
    }).catch(error => {
      console.error('获取患者数据失败:', error)
      // 返回空数组作为默认值，避免前端显示错误
      return []
    })
  },
  
  // 获取患者详情
  getPatientDetail(patientId) {
    return api.get(`/患者/${patientId}`).then(patient => {
      // 规范化患者详情数据格式
      return {
        patient_id: patient.patient_id || patient['患者ID'],
        patient_name: patient.patient_name || patient['姓名'],
        id_card: patient.id_card || patient['身份证号'],
        gender: patient.gender || patient['性别'],
        birth_date: patient.birth_date || patient['出生日期'],
        phone_number: patient.phone_number || patient['联系方式'],
        address: patient.address || patient['常住地址'],
        blood_type: patient.blood_type || patient['血型'] || '未知',
        allergies: patient.allergies || patient['过敏史'] || '无',
        past_history: patient.past_history || patient['既往病史'] || '无',
        created_at: patient.created_at || patient['created_at'] || patient['创建时间'],
        creation_time: patient.creation_time || patient['creation_time'] || (patient.created_at || patient['created_at'] || patient['创建时间'] ? new Date(patient.created_at || patient['created_at'] || patient['创建时间']).toLocaleString() : new Date().toLocaleString())
      }
    }).catch(error => {
      console.error('获取患者详情失败:', error)
      throw error
    })
  },
  
  // 创建患者
  createPatient(patientData) {
    return api.post('/患者', patientData)
  },
  
  // 更新患者信息
  updatePatient(patientId, patientData) {
    return api.put(`/患者/${patientId}`, patientData)
  },
  
  // 删除患者
  deletePatient(patientId) {
    return api.delete(`/患者/${patientId}`)
  }
}

// 卒中事件相关API
export const strokeEventAPI = {
  // 获取所有卒中事件
  getEvents(params = {}) {
    return api.get('/卒中事件', { params }).then(events => {
      // 规范化卒中事件数据格式
      return events.map(event => ({
        event_id: event.event_id || event['事件ID'],
        patient_id: event.patient_id || event['患者ID'],
        onset_time: event.onset_time || event['发病时间'],
        admission_time: event.admission_time || event['入院时间'],
        discharge_time: event.discharge_time || event['出院时间'],
        affected_location: event.affected_location || event['发病部位'],
        severity: event.severity || event['严重程度'],
        event_type: event.event_type || event['事件类型'],
        recurrence: event.recurrence || event['是否复发'],
        clinical_manifestations: event.clinical_manifestations || event['临床表现'],
        imaging_results: event.imaging_results || event['影像学检查结果'],
        creation_time: event.creation_time || event['创建时间'] || (event.created_at || event['created_at'] ? new Date(event.created_at || event['created_at']).toLocaleString() : new Date().toLocaleString()),
        update_time: event.update_time || event['更新时间']
      }))
    }).catch(error => {
      console.error('获取卒中事件失败:', error)
      return []
    })
  },
  
  // 获取卒中事件详情
  getEventDetail(eventId) {
    return api.get(`/卒中事件/${eventId}`)
  },
  
  // 创建卒中事件
  createEvent(eventData) {
    return api.post('/卒中事件', eventData)
  },
  
  // 更新卒中事件
  updateEvent(eventData) {
    // 查找对应的记录ID
    return api.get('/卒中事件', {
      params: { event_id: eventData.event_id }
    }).then(records => {
      if (records && records.length > 0) {
        const recordId = records[0].id
        return api.put(`/卒中事件/${recordId}`, eventData)
      }
      throw new Error('未找到对应的卒中事件记录')
    })
  },
  
  // 添加卒中事件（别名，与前端组件调用一致）
  addEvent(eventData) {
    return api.post('/卒中事件', eventData)
  },
  
  // 删除卒中事件
  deleteEvent(eventId) {
    // 查找对应的记录ID
    return api.get('/卒中事件', {
      params: { event_id: eventId }
    }).then(records => {
      if (records && records.length > 0) {
        const recordId = records[0].id
        return api.delete(`/卒中事件/${recordId}`)
      }
      throw new Error('未找到对应的卒中事件记录')
    })
  }
}

// 治疗记录相关API
export const treatmentAPI = {
  // 获取所有治疗记录
  getRecords(params = {}) {
    return api.get('/治疗记录', { params })
  },
  
  // 创建治疗记录
  createRecord(recordData) {
    return api.post('/治疗记录', recordData)
  },
  
  // 更新治疗记录
  updateRecord(recordId, recordData) {
    return api.put(`/治疗记录/${recordId}`, recordData)
  }
}

// 医疗机构相关API
export const institutionAPI = {
  // 获取所有医疗机构
  getInstitutions() {
    return api.get('/医疗机构')
  }
}

// 政策文件相关API
export const policyAPI = {
  // 获取所有政策文件
  getPolicies() {
    return api.get('/卒中政策文件')
  },
  
  // 为了兼容视图中的调用，添加别名
  getDocuments() {
    return api.get('/卒中政策文件')
  },
  
  // 获取政策文件详情
  getPolicyDetail(policyId) {
    return api.get(`/卒中政策文件/${policyId}`)
  }
}

// 新闻公告相关API
export const newsAPI = {
  // 获取所有新闻公告
  getNews() {
    return api.get('/卒中新闻公告')
  },
  
  // 获取新闻公告详情
  getNewsDetail(newsId) {
    return api.get(`/卒中新闻公告/${newsId}`)
  },
  
  // 添加新闻公告
  addNews(newsData) {
    return api.post('/卒中新闻公告', newsData)
  },
  
  // 更新新闻公告
  updateNews(newsData) {
    // 查找对应的记录ID
    return api.get('/卒中新闻公告', {
      params: { 公告ID: newsData.公告ID }
    }).then(records => {
      if (records && records.length > 0) {
        const recordId = records[0].id
        return api.put(`/卒中新闻公告/${recordId}`, newsData)
      }
      throw new Error('未找到对应的新闻公告记录')
    })
  },
  
  // 删除新闻公告
  deleteNews(newsId) {
    // 查找对应的记录ID
    return api.get('/卒中新闻公告', {
      params: { 公告ID: newsId }
    }).then(records => {
      if (records && records.length > 0) {
        const recordId = records[0].id
        return api.delete(`/卒中新闻公告/${recordId}`)
      }
      throw new Error('未找到对应的新闻公告记录')
    })
  }
}

// 下载请求相关API
export const downloadAPI = {
  // 获取下载请求列表
  getRequests(params = {}) {
    return api.get('/下载请求', { params })
  },
  
  // 创建下载请求
  createRequest(requestData) {
    return api.post('/下载请求', requestData)
  },
  
  // 更新下载请求状态
  updateRequest(requestId, requestData) {
    return api.put(`/下载请求/${requestId}`, requestData)
  }
}

// 评论相关API
export const commentAPI = {
  // 添加评论
  addComment(commentData) {
    return api.post('/comments', commentData)
  },
  
  // 添加弹幕
  addDanmaku(danmakuData) {
    return api.post('/danmakus', danmakuData)
  }
}

// 用户交互相关API
export const interactionAPI = {
  // 点赞视频
  likeVideo(user_id, video_id) {
    return api.post('/userLikeVideos', { user_id, video_id })
  },
  
  // 取消点赞
  unlikeVideo(relationId) {
    return api.delete(`/userLikeVideos/${relationId}`)
  },
  
  // 收藏视频
  collectVideo(user_id, video_id) {
    return api.post('/userCollectVideos', { user_id, video_id })
  },
  
  // 取消收藏
  uncollectVideo(relationId) {
    return api.delete(`/userCollectVideos/${relationId}`)
  },
  
  // 投币
  coinVideo(user_id, video_id, coin_value) {
    return api.post('/userCoinVideos', { user_id, video_id, coin_value })
  },
  
  // 获取用户点赞列表
  getUserLikes(userId) {
    return api.get('/userLikeVideos', {
      params: { user_id: userId }
    })
  },
  
  // 获取用户收藏列表
  getUserCollections(userId) {
    return api.get('/userCollectVideos', {
      params: { user_id: userId }
    })
  },
  
  // 获取用户评论列表
  getUserComments(userId) {
    return api.get('/comments', {
      params: { user_id: userId }
    })
  }
}

export default api